#include <iostream>
#include <assert.h>

using namespace std;

double eps = 1e-12;
//double m_factor;
void prim_analysys_lf(int* a,int n);
void post_analysys_hf(int *a, int n);

int sort(int* a,int n) {
//    prim_analysys_lf(a,n);
//    cout << "\nafter prim analysys\n";
//   for (int i = 0; i < n; ++i)
//        cout << a[i] << ' ';
//    cout << '\n';
	
    post_analysys_hf(a,n);
    return 0;
}

void prim_analysys_lf(int* a,int n) {
    int m = n >> 1;
    int* gt = new int[m];
    int i, k = 0;
    int anliv = a[0];
    int nri = 0;

    for (i = 1; i < n; i++) {
        if (a[i] < anliv) 
            anliv = a[i]; // anliv - наименьший элемент массива

        if (a[i] > a[nri]) // nri - индекс наибольшего элемента массива
	    nri = i;
    }
//    m_factor = 1; // 1
    if ((anliv)/(double)(a[nri]) == 1.0) // все числа равны. Но не совсем.    
        return;
    double s_factor = ((double) m - 1 )/(a[nri] - anliv); // (n/2 - 1) / (max - min)

    for (i = 0; i < n; i++) {
        k = (int) (s_factor * (a[i] - anliv)); // (n/1 - 1) * (cur - min))/ (max - min)
//        m_factor += eps;
        gt[k]++;
    }
//    cout << "\nMfactor is "  << m_factor << '\n';
    // m_factor = 1 + n * 1e-12; 
    // gt[k] - какая-то странная гистограмма
    for (k = 1; k < m; k++) {
        gt[k] += gt[k - 1];
    }
    // что-то типа функции распределения вероятности
    // Т.е. в итоге возрастающая гистограмма распределения элементов

    int hold = a[nri]; 
    a[nri] = a[0];
    a[0] = hold;
    // swap(max, a[0])

    int st_loc = 0;

    int* tlb = new int[3];
    tlb[1] = 0; 
    tlb[2] = m - 1;

    while (st_loc < n - 1) { // ПОКА ХЗ
        while(tlb[1] > (gt[tlb[2]] - 1)) {  
            tlb[1]++;
            tlb[2] = (int) (s_factor * (a[tlb[1]] - anliv)); // (n/2 - 1)*(k - min) / (max - min)
        }
        tlb[0] = a[tlb[1]];
        while (!(tlb[1] == gt[tlb[2]])) {
            tlb[2] = (int) (s_factor * (tlb[0] - anliv)); // (n/2 - 1)*(k - min) / (max - min)

            hold = a[gt[tlb[2]] - 1];
            a[gt[tlb[2]] - 1] = tlb[0];
            tlb[0] = hold;
            // swap(a[gt[tlb[2]] - 1], tlb[0])

            gt[tlb[2]]--;
            st_loc++;
        }
    }
}

void post_analysys_hf (int *a, int n) {

    int anl = a[0];
    int nr = 0;
    for (int i=0; i < n; i++) {
        if (a[i] < anl) 
            anl = a[i];
        if (a[i] > a[nr])
            nr = i;
    }
    // anl = min
    // nr = index of max

    int l = anl; // min
    int r = a[nr]; // max

    int cnt[r - l + 1];
    for(int i = l; i <= r; ++i)
        cnt[i - l] = 0;
    // забиваем массив нулями

    for(int i = 0; i < n; ++i) {
        cnt[a[i] - l] += 1;
 //       m_factor -= eps;
    }

    for(int i = l; i <= r; ++i)
        for(int j = cnt[i - l]; j--;) {
            *a++ = i;//*(int)(m_factor);
	}
    return;
}

int main() {
    int i = 0;
    int sn;
    cin >> sn;
    int* inp = new int[sn];
    while (i < sn && cin >> inp[i])
        i++;
    sort(inp,i);
    i = 0;
    while (i < sn) {
        cout << inp[i] << " ";
        i++;
    }
    return 0;
}
